package org.project;

import core.data.DataHandle;
import org.project.entity.dto.DigitalDto;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.PostMapping;

@Service
public class DigitalService {
    @PostMapping("/digital")
    public void save(DataHandle<DigitalDto, ?> handle) {
        DigitalDto params = handle.getParams();
    }

    public static byte[] hexStringToByteArray(String hexStr) {
        int len = hexStr.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(hexStr.charAt(i), 16) << 4)
                    + Character.digit(hexStr.charAt(i+1), 16));
        }
        return data;
    }

    /**
     * 解析一个16位有符号整数（2个字节）
     * @param data 字节数组
     * @param offset 偏移量（从哪个字节开始解析）
     * @return 解析后的有符号整数
     */
    public static int parseSignedInt16(byte[] data, int offset) {
        return (data[offset] << 8) | (data[offset + 1] & 0xFF);
    }

    /**
     * 解析一个16位无符号整数（2个字节）
     * @param data 字节数组
     * @param offset 偏移量（从哪个字节开始解析）
     * @return 解析后的无符号整数
     */
    public static int parseUnsignedInt16(byte[] data, int offset) {
        return ((data[offset] & 0xFF) << 8) | (data[offset + 1] & 0xFF);
    }

    /**
     * 解析一个32位有符号整数（4个字节）
     * @param data 字节数组
     * @param offset 偏移量（从哪个字节开始解析）
     * @return 解析后的有符号整数
     */
    public static long parseSignedInt32(byte[] data, int offset) {
        return ((data[offset] & 0xFFL) << 24) |
                ((data[offset + 1] & 0xFFL) << 16) |
                ((data[offset + 2] & 0xFFL) << 8) |
                (data[offset + 3] & 0xFFL);
    }

    /**
     * 解析一个32位IEEE 754浮点数（4个字节）
     * @param data 字节数组
     * @param offset 偏移量（从哪个字节开始解析）
     * @return 解析后的浮点数
     */
    public static float parseFloat32(byte[] data, int offset) {
        int intBits = ((data[offset] & 0xFF) << 24) |
                ((data[offset + 1] & 0xFF) << 16) |
                ((data[offset + 2] & 0xFF) << 8) |
                (data[offset + 3] & 0xFF);
        return Float.intBitsToFloat(intBits);
    }

    /**
     * 解析一个64位IEEE 754双精度浮点数（8个字节）
     * @param data 字节数组
     * @param offset 偏移量（从哪个字节开始解析）
     * @return 解析后的双精度浮点数
     */
    public static double parseFloat64(byte[] data, int offset) {
        long longBits = ((long)(data[offset] & 0xFF) << 56) |
                ((long)(data[offset + 1] & 0xFF) << 48) |
                ((long)(data[offset + 2] & 0xFF) << 40) |
                ((long)(data[offset + 3] & 0xFF) << 32) |
                ((long)(data[offset + 4] & 0xFF) << 24) |
                ((data[offset + 5] & 0xFF) << 16) |
                ((data[offset + 6] & 0xFF) << 8) |
                (data[offset + 7] & 0xFF);
        return Double.longBitsToDouble(longBits);
    }

    /**
     * 解析一个位（bit）到布尔值
     * 注意：这通常是从一个字节的特定位提取的，而不是整个字节
     * @param data 字节数组
     * @param offset 字节的偏移量
     * @param bitIndex 位索引（0-7）
     * @return 对应的布尔值
     */
    public static boolean parseBitToBoolean(byte[] data, int offset, int bitIndex) {
        int mask = 1 << bitIndex;

        // 使用位与操作来检查该位是否被设置
        return (data[offset] & mask) != 0;
    }
}
